// Copyright (c) 2005  INRIA Sophia-Antipolis (France).
// All rights reserved.
//
// This file is part of cgal-python; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; version 2.1 of the License.
// See the file LICENSE.LGPL distributed with cgal-python.
//
// Licensees holding a valid commercial license may use this file in
// accordance with the commercial license agreement provided with the software.
//
// This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
// WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
//
// $Id: Py_Regular_Triangulation_2_doc.h 159 2007-11-02 09:54:13Z spion $
// $URL: svn+ssh://scm.gforge.inria.fr/svn/cgal-python/trunk/cgal-python/bindings/Triangulations_2/Py_Regular_Triangulation_2_doc.h $
//
// Author(s)     : Naceur Meskini
//=========================================================================

#ifndef REGULAR_TRIANGULATION_2_DOCS_H
#define REGULAR_TRIANGULATION_2_DOCS_H
//=======================================================
//	doc of Triangulation_2 module
//=======================================================
enum Regular_2_docs_kind {
	Triangulation_2_doc,
	swap_doc,
	clear_doc,
	dimension_doc,
	number_of_vertices_doc,
	number_of_faces_doc,
	infinite_vertex_doc,
	finite_vertex_doc,
	infinite_face_doc,
	infinite_tester_doc,
	is_infinite_doc,
	is_edge_doc,
	includes_edge_doc,
	is_face_doc,
	locate_doc,
	oriented_side_doc,
	side_of_oriented_circle_doc,
	flip_doc,
	insert_doc,
	push_back_doc,
	remove_doc,
	insert_first_doc,
	insert_second_doc,
	insert_in_face_doc,
	insert_in_edge_doc,
	insert_outside_convex_hull_doc,
	remove_degree_3_doc,
	remove_second_doc,
	remove_first_doc,
	ccw_doc,
	cw_doc,
	triangle_doc,
	segment_doc,
	circumcenter_doc,
	vertices_doc,
	incident_faces_doc,
	incident_edges_doc,
	incident_vertices_doc,
	last
};
const char* Regular_2_docs[] = {
	"The class Triangulation_2 is the basic class designed to handle triangulations of set of points  A in the plane.\n"\
	"Such a triangulation has vertices at the points of A and its domain covers the convex hull of A.\n" \
	"It can be viewed as a planar partition of the plane whoses bounded faces are triangular and cover the convex hull of A.\n"\
	"The single unbounded face of this partition is the complementary of the convex hull of A.\n" \
	" \n"\
	"Creation:  \n\n"\
	"t = Triangulation_2(self) Introduces an empty triangulation t.\n"\
	"t = Triangulation_2(self,Triangulation_2 tr)\n"\
	"Copy constructor. All the vertices and faces are duplicated.\n"\
	"After the copy, t and tr refer to different triangulations : if tr is modified, t is not.\n"\
	"\n"\
	"Complete C++ documentation is available at:\n"\
	"http://www.cgal.org/Manual/doc_html/cgal_manual/Triangulation_2_ref/Class_Triangulation_2.html\n",
	"swap (self,Triangulation_2)\n"\
	"t.swap(tr) \n"\
	"The triangulations tr and t are swapped. t.swap(tr) should be preferred to t = tr or to t(tr).\n",
	"clear(self) \n"	\
	"Deletes all faces and finite vertices resulting in an empty triangulation.\n",
	"dimension(self) --> int\n"\
	"Returns the dimension of the convex hull\n",
	"number_of_vertices(self) --> size_type \n"\
	"Returns the number of finite vertices.\n",
	"number_of_faces(self) --> size_type\n\n"\
	"Returns the number of finite faces.\n",
	"infinite_vertex(self) --> Vertex_handle\n\n"\
	"the infinite_vertex.\n",
	"finite_vertex(self) --> Vertex_handle\n\n"\
	"a vertex distinct from the infinite_vertex.",
	"infinite_face(self) --> Face_handle\n\n"\
	"a face incident to the infinite_vertex.\n\n",
	"infinite_tester(self) --> Infinite_tester\n\n",
	"is_infinite(self,Vertex_handle v) --> bool\n\n"\
	"true iff v is the infinite_vertex.\n\n"\
	"is_infinite(self,Face_handle f) -->bool\n\n"\
	"true iff face f is infinite.\n\n"\
	"is_infinite(self,Face_handle f, int i) --> bool\n\n"\
	"true iff edge(f,i) is infinite.\n\n"\
	"is_infinite(self,Edge e) --> bool\n\n"\
	"true iff edge e is infinite.\n",
	"is_edge(self,Vertex_handle va, Vertex_handle vb) -> bool\n\ntrue if there is an edge having va and vb as vertices.\n\n"\
	"is_edge (self, Vertex_handle va,Vertex_handle vb,Face_handle& fr,int & i) -> bool\n\n"\
	"as above. In addition, if true is returned, the edge with vertices va and vb is the edge e=(fr,i) where fr is a handle to the face incident to e and on the right side of e oriented from va to vb.\n\n",
	"includes_edge(self,Vertex_handle va,Vertex_handle & vb,Face_handle& fr,int & i) -> bool\n\n"\
	"true if the line segment from va to vb includes an edge e incident to va. If true, vb becomes the other vertex of e, e is the edge(fr,i) where fr is a handle to the face incident to e and on the right side e oriented from va to vb.\n\n",
	"is_face(self,Vertex_handle v1,Vertex_handle v2,Vertex_handle v3) -> bool \n\n"\
	"true if there is a face having v1, v2 and v3 as vertices.\n\n"\
	"is_face(self,Vertex_handle v1,Vertex_handle v2,Vertex_handle v3,Face_handle &fr) -> bool \n\n"\
	"as above. In addition, if true is returned, fr is a handle to the face with v1, v2 and v3 as vertices.\n\n",
	"locate(self,Point_2 query, Face_handle f = Face_handle()) -> Face_handle\n\n"\
	"If the point query lies inside the convex hull of the points, a face that contains the query in its interior or on its boundary is returned.\n"\
	"If the point query lies outside the convex hull of the triangulation but in the affine hull, the returned face is an infinite face which is a proof of the point's location :\n"\
	"- for a two dimensional triangulation, it is a face ( , p, q) such that query lies to the left of the oriented line pq (the rest of the triangulation lying to the right of this line).\n"\
	"- for a degenerate one dimensional triangulation it is the (degenarate one dimensional) face ( , p, NULL) such that query and the triangulation lie on either side of p.\n"\
	"If the point query lies outside the affine hull, the returned Face_handle is None.The optional Face_handle argument, if provided, is used as a hint of where the locate process has to start its search.\n\n"\
	"locate(self,Point_2 query,Locate_type& lt,int& li,Face_handle h =Face_handle()) -> Face_handle\n\n"\
	"Same as above. Additionally, the parameters lt and li describe where the query point is located. The variable lt is set to the locate type of the query.\n"\
	"If lt==VERTEX the variable li is set to the index of the vertex, and if lt==EDGE li is set to the index of the vertex opposite to the edge. Be careful that li has no meaning when the query type is FACE,\n"\
	"OUTSIDE_CONVEX_HULL, or OUTSIDE_AFFINE_HULL or when the triangulation is 0-dimensional.\n\n",
	"oriented_side(sel,Face_handle f, Point_2 p) -> Oriented_side\n\n"\
	"Returns on which side of the oriented boundary of f lies the point p. Precondition: f is finite.\n\n",
	"side_of_oriented_circle(self, Face_handle f, Point_2 p) -> Oriented_side\n\n"\
	"Returns on which side of the circumcircle of face f lies the point p.\n" \
	"The circle is assumed to be counterclockwisely oriented, so its positive side correspond to its bounded side.\n"\
	"This predicate is available only if the corresponding predicates on points is provided in the geometric traits class.\n\n",
	"flip(self,Face_handle f, int i) -> void \n\n"\
	"Exchanges the edge incident to f and f->neighbor(i) with the other diagonal of the quadrilateral formed by f and f->neighbor(i).\n"\
	"Precondition: The faces f and f->neighbor(i) are finite faces and their union form a convex quadrilateral.\n\n",
	"insert(self,Point_2 p, Face_handle f = Face_handle()) ->Vertex_handle\n\n"\
	"Inserts point p in the triangulation and returns the corresponding vertex.\n"\
	"If point p coincides with an already existing vertex, this vertex is returned and the triangulation remains unchanged.\n"\
	"If point p is on an edge, the two incident faces are split in two.\n"
	"If point p is strictly inside a face of the triangulation, the face is split in three.\n"\
	"If point p is strictly outside the convex hull, p is linked to all visible points on the convex hull to form the new triangulation.\n"\
	"At last, if p is outside the affine hull(in case of degenerate 1-dimensional or 0-dimensional triangulations),\n"\
	"p is linked all the other vertices to form a triangulation whose dimension is increased by one.\n"\
	"The last argument f is an indication to the underlying locate algorithm of where to start.\n\n"\
	"insert(self,Point_2 p,Locate_type lt,Face_handle loc,int li) -> Vertex_handle.\n\n"\
	"Same as above except that the location of the point p to be inserted is assumed to be given by (lt,loc,i) \n\n"\
	"insert(self,[p_1,...,p_n]) insert a list of Point_2.\n\n",
	"push_back(self, Point_2 p) Equivalent to insert(p).\n\n",
	"remove(self,Vertex_handle v) -> void\n\n"\
	"Removes the vertex from the triangulation. The created hole is retriangulated.\n"\
	"Precondition: Vertex v must be finite.\n\n",
	"insert_first(self,Point_2 p) -> Vertex_handle.\n\n"\
	"Inserts the first finite vertex .\n\n",
	"insert_second(self,Point_2 p) -> Vertex_handle.\n\n"\
	"Inserts the second finite vertex .\n\n",
	"insert_in_face(self,Point_2 p,Face_handle f) -> Vertex_handle.\n\n"\
	"Inserts vertex v in face f. Face f is modified, two new faces are created.\n"\
	"Precondition: The point in vertex v lies inside face f. .\n\n",
	"insert_in_edge(self,Point_2 p,Face_handle f,int i) -> Vertex_handle.\n\n"\
	"Inserts vertex v in edge i of f.\n"\
	"Precondition: The point in vertex v lies on the edge opposite to the vertex i of face f.\n\n",
	"insert_outside_convex_hull(self,Point_2 p,Face_handle f) -> Vertex_handle.\n\n"\
	"Inserts a point which is outside the convex hull but in the affine hull.\n"\
	"Precondition: The handle f points to a face which is a proof of the location ofp, see the description of the locate method above.\n\n"\
	"insert_outside_convex_hull(self,Point_2 p) -> Vertex_handle.\n\n"\
	"Inserts a point which is outside the affine hull.\n\n",
	"remove_degree_3(self,Vertex_handle v) -> void.\n\n"\
	"Removes a vertex of degree three. Two of the incident faces are destroyed, the third one is modified.\n"\
	"Precondition: Vertex v is a finite vertex with degree three.\n\n",
	"remove_second(self,Vertex_handle v) -> void.\n\n"\
	"Removes the before last finite vertex.\n\n",
	"remove_first(self,Vertex_handle v) -> void.\n\n"\
	"Removes the last finite vertex.\n\n",
	"ccw(self,int i) -> Returns i+1 modulo 3. Precondition: 0 <= i <= 2.\n\n",
	"cw(self,int i) -> Returns i+2 modulo 3. Precondition: 0 <= i <= 2.\n\n",
	"triangle(self,Face_handle f) -> Triangle_2 .\n\n"\
	"Returns the triangle formed by the three vertices of f.\n"\
	"Precondition: The face is finite.\n\n",
	"segment(self,Face_handle f,int i) -> Segment_2 .\n\n"\
	"Returns the line segment formed by the vertices ccw(i) and cw(i) of face f.\n"\
	"Precondition: 0 <= i <= 2. The vertices ccw(i) and cw(i) of f are finite.\n\n"\
	"segment(self,Edge e) -> Segment_2 .\n\n"\
	"Returns the line segment corresponding to edge e.\n"\
	"Precondition: e is a finite edge\n\n",
	"circumcenter(self,Face_handle f,int i) -> Point_2 .\n\n"\
	"Compute the circumcenter of the face pointed to by f.\n"\
	"This function is available only if the correspoding function is provided in the geometric traits.\n\n",
  	"vertices(self) -> VertexIterator\n\nEnumerate the finites vertices in the Triangulation.\n\n",
  	"incident_faces(self,Vertex_handle v) -> Face_circulator\n\nStarts at an arbitrary face incident to v.\n"\
	"incident_faces(self,Vertex_handle v,Face_handle f) -> Face_circulator\n\nStarts at face f.\n"\
	"Precondition: Face f is incident to vertex v.\n\n",
  	"incident_edges(self,Vertex_handle v) -> Edge_circulator\n\nStarts at an arbitrary edge incident to v.\n"\
	"incident_edges(self,Vertex_handle v,Face_handle f) -> Edge_circulator\n\nStarts at the the first edge of f incident to v, in counterclockwise order around v.\n"\
	"Precondition: Face f is incident to vertex v.\n\n",
  	"incident_vertices(self,Vertex_handle v) -> Vertex_circulator\n\nStarts at an arbitrary vertex incident to v.\n"\
	"incident_vertices(self,Vertex_handle v,Face_handle f) -> Vertex_circulator\n\nStarts at the first vertex of f adjacent to v in counterclockwise order around v.\n"\
	"Precondition: Face f is incident to vertex v.\n\n"

 } ;

#endif  //TRIANGULATION_2_DOCS_H
//====================

